home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / dev / gui / MultiDesktop.lha / MultiDesktop / ext.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-27  |  31.5 KB  |  1,300 lines
  1. /* Zusatzfunktionen */
  2. #include "multiwindows.h"
  3. #include <graphics/gfxbase.h>
  4.  
  5. void   ShowUserInfo();
  6. void   ShowDateAndMem();
  7. void   ShowSCSI();
  8. UBYTE *bstr();
  9.  
  10. extern struct ExecBase         *SysBase;
  11. extern struct MultiWindowsBase *MultiWindowsBase;
  12. extern struct ExpansionBase    *ExpansionBase;
  13. extern struct GfxBase          *GfxBase;
  14. extern struct Library          *VersionBase;
  15.  
  16.  
  17. /* RastPort-Daten sichern */
  18. void BackupRP(we)
  19.  struct WindowEntry *we;
  20. {
  21.  register struct RastPort *rp;
  22.  register struct RPBackup *ba;
  23.  
  24.  ba=AllocMem(sizeof(struct RPBackup),MEMF_PUBLIC);
  25.  if(ba==NULL) { NoMemory(); return; }
  26.  
  27.  rp=we->RastPort;
  28.  ba->Pens[0]=rp->FgPen;
  29.  ba->Pens[1]=rp->BgPen;
  30.  ba->Pens[2]=rp->AOlPen;
  31.  ba->DrawMode=rp->DrawMode;
  32.  ba->X=rp->cp_x;
  33.  ba->Y=rp->cp_y;
  34.  ba->Font=rp->Font;
  35.  ba->NextBackup=we->RPBackup;
  36.  we->RPBackup=ba;
  37. }
  38.  
  39. /* ---- RastPort-Daten wiederherstellen */
  40. void RestoreRP(we)
  41.  struct WindowEntry *we;
  42. {
  43.  register struct RastPort *rp;
  44.  register struct RPBackup *ba;
  45.  
  46.  ba=we->RPBackup;
  47.  if(ba==NULL) return;
  48.  
  49.  rp=we->RastPort;
  50.  rp->FgPen=ba->Pens[0];
  51.  rp->BgPen=ba->Pens[1];
  52.  rp->AOlPen=ba->Pens[2];
  53.  rp->DrawMode=ba->DrawMode;
  54.  rp->cp_x=ba->X;
  55.  rp->cp_y=ba->Y;
  56.  SetFont(rp,ba->Font);
  57.  
  58.  we->RPBackup=ba->NextBackup;
  59.  FreeMem(ba,sizeof(struct RPBackup));
  60. }
  61.  
  62. /* ---- Aktuelles TextAttr ermitteln */
  63. struct TextAttr *GetTextAttr()
  64. {
  65.  register struct MultiWindowsUser *mw;
  66.  
  67.  USER;
  68.  return(mw->TextAttr);
  69. }
  70.  
  71. /* ---- Aktuelles NonPropTextAttr ermitteln */
  72. struct TextAttr *GetNonPropTextAttr()
  73. {
  74.  register struct MultiWindowsUser *mw;
  75.  
  76.  USER;
  77.  return(mw->NonPropTextAttr);
  78. }
  79.  
  80. /* ---- Aktuelles TextAttr ermitteln */
  81. struct TextAttr *GetDefaultTextAttr()
  82. {
  83.  return(MultiWindowsBase->DefaultAttr);
  84. }
  85.  
  86. /* ---- Aktuelles NonPropTextAttr ermitteln */
  87. struct TextAttr *GetDefaultNonPropTextAttr()
  88. {
  89.  return(MultiWindowsBase->DefaultNonPropAttr);
  90. }
  91.  
  92. /* ---- Aktuelles TextAttr ermitteln */
  93. struct TextAttr *GetBoldTextAttr()
  94. {
  95.  register struct MultiWindowsUser *mw;
  96.  
  97.  USER;
  98.  return(mw->BoldTextAttr);
  99. }
  100.  
  101. /* ---- Aktuellen TextFont ermitteln */
  102. struct TextFont *GetTextFont()
  103. {
  104.  register struct MultiWindowsUser *mw;
  105.  
  106.  USER;
  107.  return(mw->TextFont);
  108. }
  109.  
  110. /* ---- Aktuellen NonPropTextFont ermitteln */
  111. struct TextFont *GetNonPropTextFont()
  112. {
  113.  register struct MultiWindowsUser *mw;
  114.  
  115.  USER;
  116.  return(mw->NonPropTextFont);
  117. }
  118.  
  119. /* ---- Aktuellen TextFont ermitteln */
  120. struct TextFont *GetDefaultTextFont()
  121. {
  122.  return(MultiWindowsBase->DefaultFont);
  123. }
  124.  
  125. /* ---- Aktuellen NonPropTextFont ermitteln */
  126. struct TextFont *GetDefaultNonPropTextFont()
  127. {
  128.  return(MultiWindowsBase->DefaultNonPropFont);
  129. }
  130.  
  131. /* ---- Neue X-Position */
  132. UWORD NewX(oldX)
  133.  UWORD oldX;
  134. {
  135.  REGISTER FLOAT                    newX;
  136.  register struct MultiWindowsUser *mw;
  137.  register struct WindowEntry      *we;
  138.  register struct Screen           *scr;
  139.  
  140.  USER;
  141.  WE;
  142.  if(we==NULL) return(0);
  143.  
  144.  scr=we->Screen;
  145.  newX=(FLOAT)oldX*mw->FactorX;
  146.  newX=newX*we->FactorX;
  147.  return((UWORD)newX+(scr->WBorLeft+1));
  148. }
  149.  
  150. /* ---- Neue Y-Position */
  151. UWORD NewY(oldY)
  152.  UWORD oldY;
  153. {
  154.  REGISTER FLOAT                    newY;
  155.  register struct MultiWindowsUser *mw;
  156.  register struct WindowEntry      *we;
  157.  register struct Screen           *scr;
  158.  
  159.  USER;
  160.  WE;
  161.  if(we==NULL) return(0);
  162.  
  163.  scr=we->Screen;
  164.  newY=(FLOAT)oldY*mw->FactorY;
  165.  newY=newY*we->FactorY;
  166.  return((UWORD)newY+(UWORD)(scr->WBorTop+scr->Font->ta_YSize+1));
  167. }
  168.  
  169. /* ---- Neue Breite */
  170. UWORD NewWidth(oldX)
  171.  UWORD oldX;
  172. {
  173.  REGISTER FLOAT                    newX;
  174.  register struct MultiWindowsUser *mw;
  175.  register struct WindowEntry      *we;
  176.  
  177.  USER;
  178.  WE;
  179.  if(we==NULL) return(0);
  180.  
  181.  newX=(FLOAT)oldX*mw->FactorX;
  182.  newX=newX*we->FactorX;
  183.  return((UWORD)newX);
  184. }
  185.  
  186. /* ---- Neue Höhe */
  187. UWORD NewHeight(oldY)
  188.  UWORD oldY;
  189. {
  190.  REGISTER FLOAT                    newY;
  191.  register struct MultiWindowsUser *mw;
  192.  register struct WindowEntry      *we;
  193.  
  194.  USER;
  195.  WE;
  196.  if(we==NULL) return(0);
  197.  
  198.  newY=(FLOAT)oldY*mw->FactorY;
  199.  newY=newY*we->FactorY;
  200.  return((UWORD)newY);
  201. }
  202.  
  203. /* ---- Neue X-Position */
  204. UWORD INewX(we,oldX)
  205.  struct WindowEntry *we;
  206.  UWORD               oldX;
  207. {
  208.  REGISTER FLOAT                    newX;
  209.  register struct MultiWindowsUser *mw;
  210.  
  211.  USER;
  212.  newX=(FLOAT)oldX*we->FactorX;
  213.  return((UWORD)newX+we->InnerLeftEdge);
  214. }
  215.  
  216. /* ---- Neue Y-Position */
  217. UWORD INewY(we,oldY)
  218.  struct WindowEntry *we;
  219.  UWORD               oldY;
  220. {
  221.  REGISTER FLOAT                    newY;
  222.  register struct MultiWindowsUser *mw;
  223.  
  224.  USER;
  225.  newY=(FLOAT)oldY*we->FactorY;
  226.  return((UWORD)newY+we->InnerTopEdge);
  227. }
  228.  
  229. /* ---- Neue Breite */
  230. UWORD INewWidth(we,oldX)
  231.  struct WindowEntry *we;
  232.  UWORD               oldX;
  233. {
  234.  REGISTER FLOAT                    newX;
  235.  register struct MultiWindowsUser *mw;
  236.  
  237.  USER;
  238.  newX=(FLOAT)oldX*we->FactorX;
  239.  return((UWORD)newX);
  240. }
  241.  
  242. /* ---- Neue Höhe */
  243. UWORD INewHeight(we,oldY)
  244.  struct WindowEntry *we;
  245.  UWORD               oldY;
  246. {
  247.  REGISTER FLOAT                    newY;
  248.  register struct MultiWindowsUser *mw;
  249.  
  250.  USER;
  251.  newY=(FLOAT)oldY*we->FactorY;
  252.  return((UWORD)newY);
  253. }
  254.  
  255. /* ---- Lokalisieren */
  256. UBYTE *L(textID)
  257.  ULONG textID;
  258. {
  259.  struct MultiWindowsUser *mw;
  260.  
  261.  USER;
  262.  return(FindID(mw->Catalog,textID));
  263. }
  264.  
  265. /* ---- String in Mac-like-Format umwandeln */
  266. void MacFormat(rp,tex,x)
  267.  struct RastPort *rp;
  268.  UBYTE           *tex;
  269.  int              x;
  270. {
  271.  REGISTER UWORD i,j,k,l;
  272.  
  273.  x-=15;
  274.  if(x<0) x=0;
  275.  
  276.  k=strlen(tex);
  277.  l=TextLength(rp,tex,k);
  278.  if(l>x)
  279.   {
  280.    i=0;
  281.    j=TextLength(rp,"...",3);
  282.    l=j;
  283.    do
  284.     {
  285.      j+=TextLength(rp,&tex[i],1L);
  286.      i++;
  287.     } while(j<x);
  288.    tex[i]=0x00;
  289.    for(j=i-1;j>0;j--)
  290.     {
  291.      if(tex[j]==' ') tex[j]=0x00; else break;
  292.     }
  293.    if(tex[0]!=0x00) strcat(tex,"...");
  294.   }
  295. }
  296.  
  297. /* ---- Gadget-Rahmen zeichnen (intern) */
  298. void DrawIt(we,x,y,w,h,recessed,db,erase)
  299.  struct WindowEntry *we;
  300.  UWORD               x,y,w,h;
  301.  BOOL                recessed,db,erase;
  302. {
  303.  UBYTE                     f,b;
  304.  register struct RastPort *rp;
  305.  register struct DrawInfo *di;
  306.  
  307.  BackupRP(we);
  308.  rp=we->RastPort;
  309.  di=we->DrawInfo;
  310.  
  311.  if(!erase)
  312.   {
  313.    if(!recessed)
  314.     {
  315.      f=di->dri_Pens[SHINEPEN];
  316.      b=di->dri_Pens[SHADOWPEN];
  317.     }
  318.    else
  319.     {
  320.      b=di->dri_Pens[SHINEPEN];
  321.      f=di->dri_Pens[SHADOWPEN];
  322.     }
  323.    w--;
  324.    h--;
  325.  
  326.    SetAPen(rp,f);
  327.    Move(rp,x,y+h);
  328.    Draw(rp,x,y);
  329.    Draw(rp,x+w,y);
  330.    Move(rp,x+1,y+h-1);
  331.    Draw(rp,x+1,y+1);
  332.  
  333.    SetAPen(rp,b);
  334.    Move(rp,x+1,y+h);
  335.    Draw(rp,x+w,y+h);
  336.    Draw(rp,x+w,y);
  337.    Move(rp,x+w-1,y+h-1);
  338.    Draw(rp,x+w-1,y+1);
  339.  
  340.    if(db) DrawIt(we,x+1,y+1,w-1,h-1,!recessed,FALSE,erase);
  341.   }
  342.  else
  343.   {
  344.    RestoreBackground(we,x,y,w,2);        /* oben   */
  345.    RestoreBackground(we,x,y,3,h);        /* links  */
  346.    RestoreBackground(we,x+w-3,y,3,h);    /* rechts */
  347.    RestoreBackground(we,x,y+h-2,w,2);    /* unten  */
  348.   }
  349.  RestoreRP(we);
  350. }
  351.  
  352. /* ---- Gadget-Text zentrieren und ausgeben (intern) */
  353. void  PrintText(rp,x,y,w,text)
  354.  struct RastPort *rp;
  355.  UWORD            x,y,w;
  356.  UBYTE           *text;
  357. {
  358.  REGISTER WORD i,l;
  359.  
  360.  l=TextLength(rp,text,strlen(text));
  361.  i=(w-l)/2;
  362.  Move(rp,x+i,y+9);
  363.  Text(rp,text,strlen(text));
  364. }
  365.  
  366. /* ---- Text ausgeben */
  367. void WriteText(rp,x,y,w,h,text,justification)
  368.  struct RastPort *rp;
  369.  UWORD            x,y,w,h;
  370.  UBYTE           *text;
  371.  UWORD            justification;
  372. {
  373.  register struct TextFont *tf;
  374.  register int              i,j;
  375.  
  376.  tf=rp->Font;
  377.  i=(h-tf->tf_YSize)/2;
  378.  y+=(i+tf->tf_Baseline+1);
  379.  j=strlen(text);
  380.  i=TextLength(rp,text,j);
  381.  
  382.  switch(justification)
  383.   {
  384.    case JSF_CENTER:
  385.      Move(rp,x+((w-i)/2),y);
  386.     break;
  387.    case JSF_RIGHT:
  388.      Move(rp,x+w-i,y);
  389.     break;
  390.    default:
  391.      Move(rp,x,y);
  392.     break;
  393.   }
  394.  SetDrMd(rp,JAM1);
  395.  Text(rp,text,j);
  396. }
  397.  
  398. /* ---- Text ausgeben und falls nötig entsprechend kürzen */
  399. void WriteMText(we,x,y,width,height,text,justification,fill)
  400.  struct WindowEntry *we;
  401.  UWORD               x,y;
  402.  UWORD               width,height;
  403.  UBYTE              *text;
  404.  UBYTE               justification;
  405.  BOOL                fill;
  406. {
  407.  struct MultiWindowsUser  *mw;
  408.  register struct RastPort *rp;
  409.  register struct DrawInfo *di;
  410.  REGISTER UWORD            i,j;
  411.  UBYTE                     s[204];
  412.  
  413.  USER;
  414.  BackupRP(we);
  415.  rp=we->RastPort;
  416.  di=we->DrawInfo;
  417.  SetFont(rp,mw->TextFont);
  418.  
  419.  if(text)
  420.   {
  421.    SetAPen(rp,di->dri_Pens[TEXTPEN]);
  422.    i=strlen(text);
  423.    j=TextLength(rp,text,i);
  424.    if(j>=width)
  425.     {
  426.      if(i>198) { i=198; s[198]=0x00; }
  427.      strncpy(&s,text,i);
  428.      MacFormat(rp,&s,width);
  429.      text=&s;
  430.     }
  431.   }
  432.  
  433.  SetAPen(rp,0);
  434.  i=SetTaskPri(SysBase->ThisTask,127);
  435.  if(fill)
  436.   {
  437.    WaitBOVP(we->ViewPort);
  438.    RectFill(rp,x+2,y+1,x+width-3,y+height-2);
  439.   }
  440.  if(text)
  441.   {
  442.    SetAPen(rp,di->dri_Pens[TEXTPEN]);
  443.    WriteText(rp,x,y,width,height,text,justification);
  444.   }
  445.  SetTaskPri(SysBase->ThisTask,i);
  446.  
  447.  RestoreRP(we);
  448. }
  449.  
  450. /* PlaceText ausgeben */
  451. void PrintPP(gad)
  452.  struct MWGadget *gad;
  453. {
  454.  UBYTE                   *otext,*text,tx[200];
  455.  struct MultiWindowsUser *mw;
  456.  struct WindowEntry      *we;
  457.  struct RastPort         *rp;
  458.  struct TextFont         *tf;
  459.  int                      i,j,l,underline;
  460.  int                      x,y,w,h;
  461.  
  462.  USER;
  463.  we=gad->WindowEntry;
  464.  rp=we->RastPort;
  465.  otext=gad->NewGadget.ng_GadgetText;
  466.  if(otext==NULL) return;
  467.  
  468.  i=0; j=0; underline=0xffff;
  469.  while(otext[i]!=0x00)
  470.   {
  471.    if(otext[i]!='_')
  472.     { tx[j]=otext[i]; j++; }
  473.    else
  474.      underline=i;
  475.    i++;
  476.   }
  477.  tx[j]=0x00;
  478.  text=&tx;
  479.  
  480.  BackupRP(we);
  481.  tf=mw->TextFont;
  482.  SetFont(rp,tf);
  483.  tf=rp->Font;
  484.  j=strlen(text);
  485.  i=l=TextLength(rp,text,j);
  486.  x=gad->NewGadget.ng_LeftEdge;
  487.  y=gad->NewGadget.ng_TopEdge;
  488.  w=gad->NewGadget.ng_Width;
  489.  h=gad->NewGadget.ng_Height;
  490.  
  491.  if(gad->NewGadget.ng_Flags & PLACETEXT_IN)
  492.   {
  493.    x+=((w-i)/2);
  494.    i=(h-tf->tf_YSize)/2;
  495.    y+=(i+tf->tf_Baseline+1);
  496.   }
  497.  if(gad->NewGadget.ng_Flags & PLACETEXT_LEFT)
  498.   {
  499.    x-=INTERWIDTH+i;
  500.    i=(h-tf->tf_YSize)/2;
  501.    y+=(i+tf->tf_Baseline+1);
  502.   }
  503.  if(gad->NewGadget.ng_Flags & PLACETEXT_RIGHT)
  504.   {
  505.    x+=w+INTERWIDTH;
  506.    i=(h-tf->tf_YSize)/2;
  507.    y+=(i+tf->tf_Baseline+1);
  508.   }
  509.  else if(gad->NewGadget.ng_Flags & PLACETEXT_ABOVE)
  510.   {
  511.    x+=((w-i)/2);
  512.    y-=INTERHEIGHT+(tf->tf_YSize-tf->tf_Baseline);
  513.   }
  514.  else if(gad->NewGadget.ng_Flags & PLACETEXT_BELOW)
  515.   {
  516.    x+=((w-i)/2);
  517.    y+=h+tf->tf_Baseline+INTERHEIGHT;
  518.   }
  519.  
  520.  if(gad->NewGadget.ng_Flags & NG_HIGHLABEL)
  521.    SetAPen(rp,we->DrawInfo->dri_Pens[HIGHLIGHTTEXTPEN]);
  522.  else
  523.    SetAPen(rp,we->DrawInfo->dri_Pens[TEXTPEN]);
  524.  
  525.  gad->TextPos[TX_LEFT]=x;
  526.  gad->TextPos[TX_TOP]=y-tf->tf_Baseline;
  527.  gad->TextPos[TX_WIDTH]=l;
  528.  gad->TextPos[TX_HEIGHT]=tf->tf_YSize;
  529.  
  530.  SetDrMd(rp,JAM1);
  531.  Move(rp,x,y);
  532.  Text(rp,text,j);
  533.  
  534.  if(underline!=0xffff)
  535.   {
  536.    j=TextLength(rp,text,underline);
  537.    Move(rp,x+j,y);
  538.    Text(rp,"_",1);
  539.   }
  540.  
  541.  RestoreRP(we);
  542. }
  543.  
  544. /* ---- Innere Größe eines Fensters berechnen */
  545. void CalcInnerSize(we)
  546.  struct WindowEntry *we;
  547. {
  548.  struct Window *win;
  549.  
  550.  win=we->Window;
  551.  we->InnerTopEdge=win->BorderTop;
  552.  we->InnerLeftEdge=win->BorderLeft;
  553.  we->InnerWidth=win->Width-win->BorderLeft-win->BorderRight;
  554.  we->InnerHeight=win->Height-win->BorderTop-win->BorderBottom;
  555. }
  556.  
  557. /* ---- App-Objekt erstellen */
  558. struct AppObject *CreateAppObject(appID,type,data,ownerType,owner)
  559.  ULONG appID;
  560.  UBYTE type;
  561.  APTR  data;
  562.  UBYTE ownerType;
  563.  APTR  owner;
  564. {
  565.  struct MultiWindowsUser *mw;
  566.  struct AppObject        *ao;
  567.  
  568.  USER;
  569.  ao=AllocMem(sizeof(struct AppObject),MEMF_CLEAR|MEMF_PUBLIC);
  570.  if(ao==NULL) return(NULL);
  571.  
  572.  ao->AppID=appID;
  573.  ao->AppObjectType=type;
  574.  ao->AppObjectData=data;
  575.  ao->OwnerType=ownerType;
  576.  ao->Owner=owner;
  577.  
  578.  switch(type)
  579.   {
  580.    case AOT_ICON:
  581.      ao->AppObject=AddAppIconA(-1L,ao,data,mw->AppPort,0L,mw->Icon,NULL);
  582.     break;
  583.    case AOT_MENUITEM:
  584.      ao->AppObject=AddAppMenuItemA(-1L,ao,data,mw->AppPort,0L);
  585.     break;
  586.    case AOT_WINDOW:
  587.      ao->AppObject=AddAppWindowA(-1L,ao,data,mw->AppPort,0L);
  588.     break;
  589.   }
  590.  
  591.  if(ao->AppObject!=NULL)
  592.    AddTail(&mw->AppObjectList,ao);
  593.  else
  594.   {
  595.    ErrorL(1121,"CreateAppObject():\nUnable to create app object!");
  596.    FreeMem(ao,sizeof(struct AppObject));
  597.    ao=NULL;
  598.   }
  599.  
  600.  return(ao);
  601. }
  602.  
  603. /* ---- App-Objekt entfernen */
  604. void DeleteAppObject(ao)
  605.  struct AppObject *ao;
  606. {
  607.  if(ao==NULL) return;
  608.  
  609.  Remove(ao);
  610.  switch(ao->AppObjectType)
  611.   {
  612.    case AOT_ICON:
  613.      RemoveAppIcon(ao->AppObject);
  614.     break;
  615.    case AOT_MENUITEM:
  616.      RemoveAppMenuItem(ao->AppObject);
  617.     break;
  618.    case AOT_WINDOW:
  619.      RemoveAppWindow(ao->AppObject);
  620.     break;
  621.   }
  622.  FreeMem(ao,sizeof(struct AppObject));
  623. }
  624.  
  625. /* ---- App-Objekt suchen */
  626. struct AppObject *FindAppObject(appID)
  627.  ULONG appID;
  628. {
  629.  struct MultiWindowsUser *mw;
  630.  struct AppObject        *ao;
  631.  struct List             *list;
  632.  struct Node             *node;
  633.  
  634.  USER;
  635.  
  636.  for(node=mw->AppObjectList.lh_Head;node!=&mw->AppObjectList.lh_Tail;node=node->ln_Succ)
  637.   {
  638.    ao=node;
  639.    if((ao->AppID==appID)) return(ao);
  640.   }
  641.  return(NULL);
  642. }
  643.  
  644. /* ---- AppMenuItem erstellen */
  645. BOOL CreateAppMenuItem(appID,title)
  646.  ULONG  appID;
  647.  UBYTE *title;
  648. {
  649.  struct MultiWindowUser *mw;
  650.  struct AppObject       *ao;
  651.  
  652.  USER;
  653.  ao=CreateAppObject(appID,AOT_MENUITEM,FindID(mw->Catalog,title),OT_USER,NULL);
  654.  if(ao) return(TRUE); else return(FALSE);
  655. }
  656.  
  657. /* ---- AppIcon erstellen */
  658. BOOL CreateAppIcon(appID,title)
  659.  ULONG  appID;
  660.  UBYTE *title;
  661. {
  662.  struct MultiWindowUser *mw;
  663.  struct AppObject *ao;
  664.  
  665.  USER;
  666.  ao=CreateAppObject(appID,AOT_ICON,FindID(mw->Catalog,title),OT_USER,NULL);
  667.  if(ao) return(TRUE); else return(FALSE);
  668. }
  669.  
  670. /* ---- AppIcon entfernen */
  671. void DeleteAppIcon(appID)
  672.  ULONG appID;
  673. {
  674.  struct AppObject *ao;
  675.  
  676.  ao=FindAppObject(appID);
  677.  if(ao) DeleteAppObject(ao);
  678. }
  679.  
  680. /* ---- AppMenuItem entfernen */
  681. void DeleteAppMenuItem(appID)
  682.  ULONG appID;
  683. { DeleteAppIcon(appID); }
  684.  
  685. /* ---- AppWindow erstellen */
  686. BOOL CreateAppWindow(windowID)
  687.  UBYTE windowID;
  688. {
  689.  struct WindowEntry *we;
  690.  
  691.  we=FindWindowEntry(we);
  692.  if(we!=NULL)
  693.   {
  694.    we->AppWindow=CreateAppObject(-1L,AOT_WINDOW,we->Window,OT_WINDOWENTRY,we);
  695.    if(we->AppWindow) return(TRUE);
  696.   }
  697.  else
  698.    return(FALSE);
  699. }
  700.  
  701. /* ---- AppWindow entfernen */
  702. void DeleteAppWindow(windowID)
  703.  UBYTE windowID;
  704. {
  705.  struct WindowEntry *we;
  706.  
  707.  we=FindWindowEntry(we);
  708.  if(we!=NULL)
  709.    if(we->AppWindow) DeleteAppObject(we->AppWindow);
  710. }
  711.  
  712. /* ---- Aktuelles TextAttr ermitteln */
  713. UBYTE *GetTextFontName()
  714. {
  715.  register struct MultiWindowsUser *mw;
  716.  
  717.  USER;
  718.  return(mw->TextAttr->ta_Name);
  719. }
  720.  
  721. /* ---- Aktuelles NonPropTextAttr ermitteln */
  722. UBYTE *GetNonPropTextFontName()
  723. {
  724.  register struct MultiWindowsUser *mw;
  725.  
  726.  USER;
  727.  return(mw->NonPropTextAttr->ta_Name);
  728. }
  729.  
  730. /* ---- Aktuelles TextAttr ermitteln */
  731. UBYTE *GetDefaultTextFontName()
  732. {
  733.  return(MultiWindowsBase->DefaultAttr->ta_Name);
  734. }
  735.  
  736. /* ---- Aktuelles NonPropTextAttr ermitteln */
  737. UBYTE *GetDefaultNonPropTextFontName()
  738. {
  739.  return(MultiWindowsBase->DefaultNonPropAttr->ta_Name);
  740. }
  741.  
  742. /* ---- Aktuelles TextAttr ermitteln */
  743. UWORD GetTextFontHeight()
  744. {
  745.  register struct MultiWindowsUser *mw;
  746.  
  747.  USER;
  748.  return(mw->TextAttr->ta_YSize);
  749. }
  750.  
  751. /* ---- Aktuelles NonPropTextAttr ermitteln */
  752. UWORD GetNonPropTextFontHeight()
  753. {
  754.  register struct MultiWindowsUser *mw;
  755.  
  756.  USER;
  757.  return(mw->NonPropTextAttr->ta_YSize);
  758. }
  759.  
  760. /* ---- Aktuelles TextAttr ermitteln */
  761. UWORD GetDefaultTextFontHeight()
  762. {
  763.  return(MultiWindowsBase->DefaultAttr->ta_YSize);
  764. }
  765.  
  766. /* ---- Aktuelles NonPropTextAttr ermitteln */
  767. UWORD GetDefaultNonPropTextFontHeight()
  768. {
  769.  return(MultiWindowsBase->DefaultNonPropAttr->ta_YSize);
  770. }
  771.  
  772. /* ---- Aktuellen TextFont ermitteln */
  773. struct TextFont *GetTopazTextFont()
  774. {
  775.  return(MultiWindowsBase->TopazFont);
  776. }
  777.  
  778. /* ---- Aktuellen TextFont ermitteln */
  779. struct TextFont *GetPassword5TextFont()
  780. {
  781.  return(MultiWindowsBase->Password5Font);
  782. }
  783.  
  784. /* ---- Aktuellen TextFont ermitteln */
  785. struct TextFont *GetPassword9TextFont()
  786. {
  787.  return(MultiWindowsBase->Password9Font);
  788. }
  789.  
  790. /* ---- Aktuellen TextAttr ermitteln */
  791. struct TextAttr *GetTopazTextAttr()
  792. {
  793.  return(MultiWindowsBase->TopazAttr);
  794. }
  795.  
  796. /* ---- Aktuellen TextAttr ermitteln */
  797. struct TextAttr *GetPassword5TextAttr()
  798. {
  799.  return(MultiWindowsBase->Password5Attr);
  800. }
  801.  
  802. /* ---- Aktuellen TextAttr ermitteln */
  803. struct TextAttr *GetPassword9TextAttr()
  804. {
  805.  return(MultiWindowsBase->Password9Attr);
  806. }
  807.  
  808. /* ---- Informationsfenster öffneen */
  809. BOOL OpenInformationBox()
  810. {
  811.  UBYTE              *dat;
  812.  BOOL                bool;
  813.  struct WindowEntry *we;
  814.  
  815.  dat=GetMem(256,MEMF_ANY);
  816.  if(dat==NULL) return(FALSE);
  817.  
  818.  bool=CreateWindow(WindowID_InformationBox,"1205§Information",50,50,450,235,CW_CLOSE|CW_DEPTH|CW_SIZE|CW_DRAG, 0 ,NULL);
  819.  if(bool==FALSE) return(FALSE);
  820.  we=FindWindowEntry(WindowID_InformationBox);
  821.  we->WESpecialData[1]=dat;
  822.  
  823.  AddFrame(1,5,5,260,100,FT_DOUBLE);
  824.  AddText(1,0,10,12,250,20,0L,0,"MultiWindows",JSF_CENTER);
  825.  AddText(1,0,10,36,250,20,0L,0,"Copyright © 1995-1996 by",JSF_CENTER);
  826.  AddText(1,0,10,58,250,20,0L,0,"Thomas Dreibholz",JSF_CENTER);
  827.  AddText(1,0,10,80,250,20,0L,0,"All rights reserved.",JSF_CENTER);
  828.  
  829.  AddFrame(2,270,5,155,100,FT_DOUBLE);
  830.  AddNumber(50,0,350,12,65,20,"Chip:",CGA_LEFT|CGA_RECESSED,"%ld KB",AvailChipMem()/1024L,JSF_RIGHT);
  831.  AddNumber(51,0,350,34,65,20,"Fast:",CGA_LEFT|CGA_RECESSED,"%ld KB",AvailFastMem()/1024L,JSF_RIGHT);
  832.  AddNumber(52,0,350,56,65,20,"VMem:",CGA_LEFT|CGA_RECESSED,"%ld KB",AvailVMem()/1024L,JSF_RIGHT);
  833.  AddNumber(53,0,350,80,65,20,"Total:",CGA_LEFT|CGA_RECESSED,"%ld KB",AvailMemory()/1024L,JSF_RIGHT);
  834.  AddText(54,0,5,110,420,20,0L,CGA_RECESSED,0L,JSF_CENTER);
  835.  AddListview(55,0,5,135,420,80,0L,CLV_NONPROPFONT|CLV_READONLY,0L,0);
  836.  ShowUserInfo();
  837.  
  838.  AddMenu(100,"1135§Select item to be displayed.","1136§Display",CME_DEFAULT);
  839.  
  840.  AddItem(200,"1149§Shows informations about MultiDesktop.","MultiDesktop",0L,0L,0);
  841.  AddSubItem(119,"1137§Shows informations about the user.","1138§User",0L,"U",0);
  842.  AddSubBarItem(301);
  843.  AddSubItem(115,"1139§Shows the application list.","1140§Applications",0L,"A",0);
  844.  AddSubItem(116,"1141§Shows the wallpaper list.","1142§Wallpapers",0L,"W",0);
  845.  AddSubItem(117,"1143§Shows the pointer list.","1144§Pointers",0L,"P",0);
  846.  AddSubBarItem(302);
  847.  AddSubItem(118,"1145§Shows the cached fonts list.","1146§Cached Fonts",0L,"F",0);
  848.  
  849.  AddBarItem(201);
  850.  AddItem(202,"1150§Shows informations about your software.","1151§Software",0L,0L,0);
  851.  AddSubItem(152,"1152§Shows informations about the operating system.","1153§Operating System",0L,"O",0);
  852.  AddSubBarItem(210);
  853.  AddSubItem(104,"1154§Shows informations about libraries.","1155§Libraries",0L,"L",0);
  854.  AddSubItem(105,"1156§Shows informations about devices.","1157§Devices",0L,"D",0);
  855.  AddSubItem(106,"1158§Shows informations about resources.","1159§Resources",0L,"R",0);
  856.  AddSubItem(107,"1160§Shows informations about message ports.","1161§Ports",0L,"P",0);
  857.  AddSubItem(108,"1162§Shows informations about tasks.","1163§Tasks",0L,"T",0);
  858.  AddSubItem(109,"1164§Shows informations about semaphores.","1165§Semaphores",0L,"W",0);
  859.  AddSubItem(110,"1166§Shows informations about memory.","1167§Memory",0L,"M",0);
  860.  
  861.  AddItem(203,"1170§Shows informations about your hardware.","1171§Hardware",0L,0L,0);
  862.  AddSubItem(151,"1172§Shows informations about processors.","1173§Processors",0L,"H",0);
  863.  AddSubItem(112,"1174§Shows informations about expansion.","1175§Expansion",0L,"X",0);
  864.  AddSubItem(150,"1176§Shows informations about SCSI.","1177§SCSI",0L,"S",0);
  865.  AddSubItem(111,"1178§Shows informations about boot priorities.","1179§Boot Priorities",0L,"B",0);
  866.  AddSubBarItem(300);
  867.  AddSubItem(113,"1180§Shows informations about screen modes.","1181§Screen Modes",0L,"V",0);
  868.  
  869.  AddBarItem(204);
  870.  AddItem(205,"1190§Closes information window.","1191§Close Window","99§Are you sure?","Q", CMI_T2BOLD);
  871.  AddStdMenus();
  872.  ShowMenu();
  873.  ShowDateAndMem();
  874.  
  875.  return(TRUE);
  876. }
  877.  
  878. /* ---- Informationsfenster schließen */
  879. void CloseInformationBox()
  880. {
  881.  struct WindowEntry *we;
  882.  
  883.  we=FindWindowEntry(WindowID_InformationBox);
  884.  if(we)
  885.    DisposeMem(we->WESpecialData[1]);
  886.  DeleteWindow(WindowID_InformationBox);
  887. }
  888.  
  889. /* ---- Messages im Informationsfenster verarbeiten */
  890. BOOL HandleInformationBox(mm)
  891.  struct MultiMessage *mm;
  892. {
  893.  UBYTE                    text[256],str[256];
  894.  ULONG                    i,j,k;
  895.  BOOL                     ende;
  896.  struct MultiWindowsUser *mw;
  897.  struct WindowEntry      *we;
  898.  struct List             *liste,*liste2;
  899.  struct Node             *node;
  900.  struct Library          *lib;
  901.  struct ConfigDev        *cd;
  902.  struct BootNode         *bn;
  903.  struct UserNode         *un;
  904.  struct MemHeader        *mh;
  905.  
  906.  USER;
  907.  we=FindWindowEntry(WindowID_InformationBox);
  908.  if(we==NULL) return;
  909.  
  910.  ende=FALSE;
  911.  switch(mm->Class)
  912.   {
  913.    case MULTI_INTUITICKS:
  914.      we->WESpecialData[0]++;
  915.      if(we->WESpecialData[0]>=8)
  916.       {
  917.        we->WESpecialData[0]=0;
  918.        ShowDateAndMem();
  919.       }
  920.     break;
  921.    case MULTI_CLOSEWINDOW:
  922.      ende=TRUE;
  923.     break;
  924.    case MULTI_MENUPICK:
  925.      if((mm->ObjectID>=104)&&(mm->ObjectID<=118))
  926.       {
  927.        liste=NULL;
  928.        Forbid();
  929.        switch(mm->ObjectID)
  930.         {
  931.          case 205:
  932.            ende=TRUE;
  933.           break;
  934.          case 104:
  935.            liste=DupList(&SysBase->LibList,sizeof(struct Library));
  936.           break;
  937.          case 105:
  938.            liste=DupList(&SysBase->DeviceList,sizeof(struct Library));
  939.           break;
  940.          case 106:
  941.            liste=DupList(&SysBase->ResourceList,sizeof(struct Library));
  942.           break;
  943.          case 107:
  944.            liste=DupList(&SysBase->PortList,sizeof(struct Library));
  945.           break;
  946.          case 108:
  947.            Disable();
  948.            liste=DupList(&SysBase->TaskWait,sizeof(struct Node));
  949.            liste2=DupList(&SysBase->TaskReady,sizeof(struct Node));
  950.            Enable();
  951.            ConcatList(liste,liste2);
  952.           break;
  953.          case 109:
  954.            liste=DupList(&SysBase->SemaphoreList,sizeof(struct Node));
  955.           break;
  956.          case 110:
  957.            liste=DupList(&SysBase->MemList,sizeof(struct MemHeader));
  958.           break;
  959.          case 111:
  960.            liste=DupList(&ExpansionBase->MountList,sizeof(struct BootNode));
  961.           break;
  962.          case 112:
  963.            liste=DupList(&ExpansionBase->eb_Private05,sizeof(struct ConfigDev));
  964.           break;
  965.          case 113:
  966.            liste=DupList(&MultiWindowsBase->VideoInfoList,sizeof(struct Node));
  967.           break;
  968.          case 115:
  969.            liste=DupList(&MultiWindowsBase->AppList,sizeof(struct UserNode));
  970.           break;
  971.          case 116:
  972.            liste=DupList(&MultiWindowsBase->WallpaperList,sizeof(struct Node));
  973.           break;
  974.          case 117:
  975.            liste=DupList(&MultiWindowsBase->PointerList,sizeof(struct Node));
  976.           break;
  977.          case 118:
  978.            liste=DupList(&mw->CachedFontsList,sizeof(struct Node));
  979.           break;
  980.         }
  981.        Permit();
  982.        if(liste!=NULL)
  983.         {
  984.          Pointer(MultiWindowsBase->WorkPointerName);
  985.          SortList(liste,SORT_ASCENDING);
  986.          RemListviewEntries(55);
  987.          for(node=liste->lh_Head;node!=&liste->lh_Tail;node=node->ln_Succ)
  988.           {
  989.            if(node->ln_Name==NULL) node->ln_Name=GetLStr(98,"[Untitled]");
  990.            switch(mm->ObjectID)
  991.             {
  992.              case 104:
  993.              case 105:
  994.              case 106:
  995.                lib=node;
  996.                sprintf(&text,"%-30s  %5d.%-4d  %4d",node->ln_Name,lib->lib_Version,lib->lib_Revision,lib->lib_OpenCnt);
  997.               break;
  998.              case 110:
  999.                mh=node;
  1000.                if(mh->mh_Attributes & MEMF_CHIP)
  1001.                  strcpy(&text[200],"Chip");
  1002.                else
  1003.                 {
  1004.                  if(mh->mh_Attributes & (MEMF_FAST|MEMF_PUBLIC))
  1005.                    strcpy(&text[200],"Fast");
  1006.                  else
  1007.                    strcpy(&text[200],"VMem");
  1008.                 }
  1009.                sprintf(&text,"%-30s  %s  %5ld KB",node->ln_Name,&text[200],((ULONG)mh->mh_Upper-(ULONG)mh->mh_Lower+(ULONG)sizeof(struct MemHeader)+(ULONG)sizeof(struct MemChunk))/1024L);
  1010.               break;
  1011.              case 111:
  1012.                bn=node;
  1013.                sprintf(&text,"%-20s  %4d",bstr(&str[160],(struct DeviceNode *)(bn->bn_DeviceNode)->dn_Name),node->ln_Pri);
  1014.               break;
  1015.              case 112:
  1016.                cd=node;
  1017.                sprintf(&text,"%03ld/%03ld  $%08lx %5ld KB  ",
  1018.                              cd->cd_Rom.er_Manufacturer,
  1019.                              cd->cd_Rom.er_Product,
  1020.                              cd->cd_BoardAddr,
  1021.                              (ULONG)cd->cd_BoardSize/1024L);
  1022.  
  1023.                if((cd->cd_Rom.er_Manufacturer==513)&&(cd->cd_Rom.er_Product==1))
  1024.                  strcat(&text,"[CBM Bridgeboard]");
  1025.                else if(cd->cd_Rom.er_Manufacturer==514)
  1026.                 {
  1027.                  switch(cd->cd_Rom.er_Product)
  1028.                   {
  1029.                    case 81:
  1030.                      strcat(&text,"[CBM 68030/68882 Turbo]");
  1031.                     break;
  1032.                    case 3:
  1033.                      strcat(&text,"[CBM SCSI Controller]");
  1034.                     break;
  1035.                    case 10:
  1036.                      strcat(&text,"[CBM Memory Card]");
  1037.                     break;
  1038.                   }
  1039.                 }
  1040.               break;
  1041.              case 113:
  1042.              case 114:
  1043.              case 116:
  1044.              case 117:
  1045.              case 118:
  1046.                strcpy(&text,node->ln_Name);
  1047.               break;
  1048.              case 115:
  1049.                un=node;
  1050.                sprintf(&text,"%-36s  %2d.%03d",node->ln_Name,un->Version/1000,un->Version % 1000);
  1051.               break;
  1052.              default:
  1053.                sprintf(&text,"%-36s  %4d",node->ln_Name,node->ln_Pri);
  1054.               break;
  1055.             }
  1056.            AddListviewEntrySort(55,&text,ULP_TAIL);
  1057.            AnimPointer();
  1058.           }
  1059.         }
  1060.        if(liste) FreeList(liste);
  1061.        Pointer(NULL);
  1062.       }
  1063.      else
  1064.       {
  1065.        switch(mm->ObjectID)
  1066.         {
  1067.          case 151:
  1068.            RemListviewEntries(55);
  1069.            AddListviewEntrySort(55,GetLStr(1192,"Testing CPU/FPU/MMU..."),ULP_HEAD);
  1070.            i=GetCPUType();
  1071.            j=GetFPUType();
  1072.            k=GetMMUType();
  1073.            RemListviewEntries(55);
  1074.            AddListviewEntrySort(55,GetLStr(1193,"Main Processors:"),ULP_TAIL);
  1075.            sprintf(&text,"CPU: %ld",i);
  1076.            AddListviewEntrySort(55,&text,ULP_TAIL);
  1077.            if(j)
  1078.              sprintf(&text,"FPU: %ld",j);
  1079.            else
  1080.              strcpy(&text,GetLStr(1194,"FPU: not installed"));
  1081.            AddListviewEntrySort(55,&text,ULP_TAIL);
  1082.            if(k)
  1083.              sprintf(&text,"MMU: %ld",k);
  1084.            else
  1085.              strcpy(&text,GetLStr(1195,"MMU: not installed"));
  1086.            AddListviewEntrySort(55,&text,ULP_TAIL);
  1087.  
  1088.            AddListviewEntrySort(55,"",ULP_TAIL);
  1089.            AddListviewEntrySort(55,GetLStr(1196,"Graphics Processors:"),ULP_TAIL);
  1090.            if(GfxBase->ChipRevBits0 & GFXF_HR_AGNUS)
  1091.              AddListviewEntrySort(55,"Agnus:  ECS",ULP_TAIL);
  1092.            else
  1093.              AddListviewEntrySort(55,"Agnus:  OCS",ULP_TAIL);
  1094.  
  1095.            if(GfxBase->ChipRevBits0 & GFXF_HR_DENISE)
  1096.              AddListviewEntrySort(55,"Denise: ECS",ULP_TAIL);
  1097.            else
  1098.              AddListviewEntrySort(55,"Denise: OCS",ULP_TAIL);
  1099.           break;
  1100.          case 152:
  1101.            RemListviewEntries(55);
  1102.            sprintf(&text,"Kickstart %d.%d",SysBase->LibNode.lib_Version,SysBase->LibNode.lib_Revision);
  1103.            AddListviewEntrySort(55,&text,ULP_TAIL);
  1104.            if(VersionBase)
  1105.              sprintf(&text,"Workbench %d.%d",VersionBase->lib_Version,VersionBase->lib_Revision);
  1106.            else
  1107.              strcat(&text,"<< version.library not available >>");
  1108.            AddListviewEntrySort(55,&text,ULP_TAIL);
  1109.           break;
  1110.          case 150:
  1111.            ShowSCSI();
  1112.           break;
  1113.          case 119:
  1114.            ShowUserInfo();
  1115.           break;
  1116.          case 250:
  1117.            ende=TRUE;
  1118.           break;
  1119.         }
  1120.       }
  1121.     break;
  1122.   }
  1123.  return(ende);
  1124. }
  1125.  
  1126. UBYTE *bstr(dest,src)
  1127.  UBYTE *dest;
  1128.  BSTR   src;
  1129. {
  1130.  UWORD  i;
  1131.  UBYTE *Help;
  1132.  
  1133.  Help=(UBYTE *)BADDR(src);
  1134.  for(i=0;i<(*Help);i++)
  1135.   dest[i]=*(Help+i+1);
  1136.  dest[i]=0x00;
  1137.  return(dest);
  1138. }
  1139.  
  1140. /* ---- UserInfo anzeigen */
  1141. void ShowUserInfo()
  1142. {
  1143.  UBYTE text[256];
  1144.  
  1145.  RemListviewEntries(55);
  1146.  sprintf(&text,"%s %s",GetLStr(1198,"Name:     "),&MultiWindowsBase->UserInfo->Name);
  1147.  AddListviewEntrySort(55,&text,ULP_TAIL);
  1148.  sprintf(&text,"%s %s",GetLStr(1199,"Address:  "),&MultiWindowsBase->UserInfo->Address[0]);
  1149.  AddListviewEntrySort(55,&text,ULP_TAIL);
  1150.  sprintf(&text,"           %s",&MultiWindowsBase->UserInfo->Address[1]);
  1151.  AddListviewEntrySort(55,&text,ULP_TAIL);
  1152.  sprintf(&text,"           %s",&MultiWindowsBase->UserInfo->Country);
  1153.  AddListviewEntrySort(55,&text,ULP_TAIL);
  1154.  sprintf(&text,"%s %s",GetLStr(1200,"Phone:    "),&MultiWindowsBase->UserInfo->PhoneNumber);
  1155.  AddListviewEntrySort(55,&text,ULP_TAIL);
  1156.  sprintf(&text,"%s %s",GetLStr(1201,"Fax:      "),&MultiWindowsBase->UserInfo->FaxNumber);
  1157.  AddListviewEntrySort(55,&text,ULP_TAIL);
  1158.  AddListviewEntrySort(55,"",ULP_TAIL);
  1159.  switch(MultiWindowsBase->UserInfo->UserLevel)
  1160.   {
  1161.    case USERLEVEL_EXPERT:
  1162.      AddListviewEntrySort(55,GetLStr(1202,"Level: Expert",ULP_TAIL));
  1163.     break;
  1164.    case USERLEVEL_ADVANCED:
  1165.      AddListviewEntrySort(55,GetLStr(1203,"Level: Advanced",ULP_TAIL));
  1166.     break;
  1167.    case USERLEVEL_BEGINNER:
  1168.      AddListviewEntrySort(55,GetLStr(1204,"Level: Beginner",ULP_TAIL));
  1169.     break;
  1170.   }
  1171. }
  1172.  
  1173. /* ---- Zeitanzeige */
  1174. void ShowDateAndMem()
  1175. {
  1176.  UBYTE                    str[100];
  1177.  UBYTE                   *dat;
  1178.  struct WindowEntry      *we;
  1179.  struct MultiWindowsUser *mw;
  1180.  struct Locale           *locale;
  1181.  struct MultiTime         mt;
  1182.  struct DateStamp         ds;
  1183.  
  1184.  USER;
  1185.  GetTime(&mt);
  1186.  locale=mw->Locale;
  1187.  if(locale)
  1188.   {
  1189.    DateStamp(&ds);
  1190.    LocaleDFormat(&str,locale->loc_DateTimeFormat,&ds);
  1191.   }
  1192.  else
  1193.   {
  1194.    sprintf(&str,"%2d:%02d:%02d  %02d/%02d/%04d",mt.Hour,mt.Minute,mt.Second,mt.Month,mt.Day,mt.Year);
  1195.   }
  1196.  
  1197.  we=FindWindowEntry(WindowID_InformationBox);
  1198.  if(we)
  1199.   {
  1200.    dat=we->WESpecialData[1];
  1201.    sprintf(dat,"%s    %ld.%04ld",&str,mt.StarDate[0],mt.StarDate[1]);
  1202.    UpdateText(54,dat);
  1203.   }
  1204.  
  1205.  UpdateNumber(50,AvailChipMem()/1024L);
  1206.  UpdateNumber(51,AvailFastMem()/1024L);
  1207.  UpdateNumber(52,AvailVMem()/1024L);
  1208.  UpdateNumber(53,AvailMemory()/1024L);
  1209. }
  1210.  
  1211. /* ---- SCSI */
  1212. struct DriveInfo
  1213. {
  1214.  UBYTE PeripheralType;
  1215.  UBYTE Modifier;
  1216.  UBYTE Version;
  1217.  UBYTE Flags1;
  1218.  UBYTE AdditionalLength;
  1219.  UBYTE reserved[2];
  1220.  UBYTE Flags2;
  1221.  UBYTE Vendor[8];
  1222.  UBYTE Product[16];
  1223.  UBYTE Revision[4];
  1224. };
  1225. UBYTE Inquiry[6]={0x12,0x00,0x00,0x00,0x90,0x00};
  1226.  
  1227. void ShowSCSI()
  1228. {
  1229.  struct MsgPort   *port;
  1230.  struct IOStdReq  *io;
  1231.  struct SCSICmd   *cmd;
  1232.  struct DriveInfo *di;
  1233.  long              i,j;
  1234.  UBYTE             Sense[20];
  1235.  UBYTE             str[128],vendor[10],product[18],revision[6];
  1236.  
  1237.  RemListviewEntries(55);
  1238.  AddListviewEntrySort(55,GetLStr(1197,"Unit  Device     Vendor     Type"),ULP_TAIL);
  1239.  Pointer(MultiWindowsBase->WorkPointerName);
  1240.  
  1241.  di=AllocVec(sizeof(struct DriveInfo),MEMF_PUBLIC|MEMF_24BITDMA);
  1242.  if(di!=NULL)
  1243.   {
  1244.    port=CreatePort(0,0);
  1245.    if(port!=NULL)
  1246.     {
  1247.      io=CreateExtIO(port,sizeof(struct IOStdReq));
  1248.      if(io!=NULL)
  1249.       {
  1250.        for(i=0;i<=7;i++)
  1251.         {
  1252.          j=OpenDevice("scsi.device",i,io,0);
  1253.          if(j==0)
  1254.           {
  1255.            cmd=AllocVec(sizeof(struct SCSICmd),MEMF_PUBLIC|MEMF_CLEAR);
  1256.            if(cmd!=NULL)
  1257.             {
  1258.              for(j=0;j<20;j++) Sense[j]=0x00;
  1259.              io->io_Length=sizeof(struct SCSICmd);
  1260.              io->io_Data=cmd;
  1261.              io->io_Command=HD_SCSICMD;
  1262.              cmd->scsi_Data=di;
  1263.              cmd->scsi_Length=sizeof(struct DriveInfo);
  1264.              cmd->scsi_Flags=SCSIF_AUTOSENSE|SCSIF_READ;
  1265.              cmd->scsi_SenseData=AllocMem(20,MEMF_PUBLIC|MEMF_CLEAR);
  1266.              cmd->scsi_SenseLength=18;
  1267.              cmd->scsi_SenseActual=0;
  1268.              cmd->scsi_Command=&Inquiry;
  1269.              cmd->scsi_CmdLength=6;
  1270.              DoIO(io);
  1271.  
  1272.              if(cmd->scsi_Status!=0)
  1273.                sprintf(&str,"%4ld   SCSI I/O Error #%ld",cmd->scsi_Status);
  1274.              else
  1275.               {
  1276.                strncpy(&vendor,&di->Vendor,8); vendor[8]=0x00;
  1277.                strncpy(&product,&di->Product,16); product[16]=0x00;
  1278.                strncpy(&revision,&di->Revision,4); revision[4]=0x00;
  1279.                sprintf(&str,"%4ld   %-8s   %-16s  %-4s",i,&vendor,&product,&revision);
  1280.               }
  1281.              FreeVec(cmd);
  1282.             }
  1283.            CloseDevice(io);
  1284.           }
  1285.          else
  1286.            sprintf(&str,"%4ld  N/A",i);
  1287.  
  1288.          AddListviewEntryNumber(55,&str,999);
  1289.          AnimPointer();
  1290.         }
  1291.        DeleteExtIO(io);
  1292.       }
  1293.      DeletePort(port);
  1294.     }
  1295.    FreeVec(di);
  1296.   }
  1297.  Pointer(NULL);
  1298. }
  1299.  
  1300.